// 计算器工具类
class Calculator {
  constructor() {
    this.history = [];
    this.currentExpression = '';
  }

  // 安全的表达式计算
  calculate(expression) {
    try {
      if (!expression || expression.trim() === '') {
        return 'Error';
      }

      // 替换常用数学函数和常数
      const processedExp = expression
        .replace(/sin\(/g, 'Math.sin(')
        .replace(/cos\(/g, 'Math.cos(')
        .replace(/tan\(/g, 'Math.tan(')
        .replace(/log\(/g, 'Math.log10(')
        .replace(/ln\(/g, 'Math.log(')
        .replace(/sqrt\(/g, 'Math.sqrt(')
        .replace(/π/g, 'Math.PI')
        .replace(/e/g, 'Math.E')
        .replace(/\^/g, '**')
        .replace(/×/g, '*')
        .replace(/÷/g, '/')
        .replace(/−/g, '-');

      // 验证表达式安全性
      if (this.isValidExpression(processedExp)) {
        const result = Function('"use strict"; return (' + processedExp + ')')();
        
        // 检查结果是否有效
        if (isNaN(result) || !isFinite(result)) {
          return 'Error';
        }
        
        // 格式化结果
        const formattedResult = this.formatResult(result);
        
        // 添加到历史记录
        this.addToHistory(expression, formattedResult);
        
        return formattedResult;
      }
      throw new Error('Invalid expression');
    } catch (error) {
      console.error('计算错误:', error);
      return 'Error';
    }
  }

  // 验证表达式是否安全
  isValidExpression(exp) {
    // 检查危险模式
    const dangerousPatterns = [
      /eval/,
      /function/,
      /window/,
      /document/,
      /alert/,
      /console/,
      /require/,
      /import/,
      /export/,
      /this/,
      /global/,
      /process/
    ];
    
    // 检查是否包含危险模式
    if (dangerousPatterns.some(pattern => pattern.test(exp))) {
      return false;
    }
    
    // 检查是否只包含允许的字符
    const allowedPattern = /^[0-9+\-*/.()\s\w]*$/;
    if (!allowedPattern.test(exp)) {
      return false;
    }
    
    // 检查括号是否匹配
    let openBrackets = 0;
    for (let char of exp) {
      if (char === '(') openBrackets++;
      if (char === ')') openBrackets--;
      if (openBrackets < 0) return false;
    }
    
    return openBrackets === 0;
  }

  // 格式化计算结果
  formatResult(result) {
    // 处理整数
    if (Number.isInteger(result)) {
      return result.toString();
    }
    
    // 处理小数
    const precision = 10; // 最多10位小数
    let formatted = parseFloat(result.toPrecision(precision));
    
    // 如果结果太大或太小，使用科学记数法
    if (Math.abs(formatted) >= 1e10 || (Math.abs(formatted) < 1e-6 && formatted !== 0)) {
      return formatted.toExponential(6);
    }
    
    return formatted.toString();
  }

  // 添加到历史记录
  addToHistory(expression, result) {
    const historyItem = {
      expression: expression,
      result: result,
      timestamp: Date.now()
    };
    
    // 避免重复记录
    const isDuplicate = this.history.some(item => 
      item.expression === expression && item.result === result
    );
    
    if (!isDuplicate) {
      this.history.unshift(historyItem);
      
      // 最多保存50条记录
      if (this.history.length > 50) {
        this.history = this.history.slice(0, 50);
      }
    }
  }

  // 清除历史记录
  clearHistory() {
    this.history = [];
  }

  // 获取历史记录
  getHistory() {
    return this.history;
  }

  // 角度转弧度
  degToRad(degrees) {
    return degrees * (Math.PI / 180);
  }

  // 弧度转角度
  radToDeg(radians) {
    return radians * (180 / Math.PI);
  }

  // 阶乘计算
  factorial(n) {
    if (n < 0) return NaN;
    if (n === 0 || n === 1) return 1;
    if (n > 170) return Infinity; // 防止溢出
    
    let result = 1;
    for (let i = 2; i <= n; i++) {
      result *= i;
    }
    return result;
  }

  // 百分比计算
  percentage(value, percent) {
    return (value * percent) / 100;
  }

  // 验证数字输入
  isValidNumber(str) {
    return !isNaN(str) && !isNaN(parseFloat(str));
  }

  // 格式化显示数字（添加千分位分隔符）
  formatDisplayNumber(num) {
    if (typeof num !== 'number') {
      num = parseFloat(num);
    }
    
    if (isNaN(num)) return '0';
    
    // 对于大数字使用科学记数法
    if (Math.abs(num) >= 1e15) {
      return num.toExponential(6);
    }
    
    // 对于小数，保留适当的精度
    if (num % 1 !== 0) {
      return num.toLocaleString('zh-CN', {
        maximumFractionDigits: 10,
        minimumFractionDigits: 0
      });
    }
    
    // 对于整数，添加千分位分隔符
    return num.toLocaleString('zh-CN');
  }
}

module.exports = Calculator;